package com.yt.product.service;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.yt.product.common.config.YmlConfig;
import com.yt.product.mapper.SupplierInfoMapper;
import com.yt.product.models.bo.SupplierInfoBO;
import com.yt.product.models.bo.SupplierInfoSaveBO;
import com.yt.product.models.dto.SupplierInfoDTO;
import com.yt.product.models.service.ISupplierInfoService;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;

/**
 * 供应商信息服务实现类
 *
 * @author lianyadong
 * @Date 2025-09-03 14:16:03
 */
@Slf4j
@Service
@Component
public class SupplierInfoServiceImpl extends ServiceImpl<SupplierInfoMapper, SupplierInfoDTO> implements ISupplierInfoService {

    @Resource
    private YmlConfig ymlConfig;

    @Resource
    private SupplierInfoMapper supplierInfoMapper;

    /**     * 新增供应商     */
    @Override
    public boolean add(SupplierInfoSaveBO saveBO) {
        if (saveBO == null) {
            log.error("新增供应商失败：传入的SaveBO为空");
            return false;
        }
        SupplierInfoDTO dto = new SupplierInfoDTO();
        BeanUtils.copyProperties(saveBO, dto);
        // 生成ID
        Long id = ymlConfig.getPkId();
        if (id == null || id <= 0) {
            log.error("新增供应商失败：生成的ID无效（id={}）", id);
            return false;
        }
        dto.setId(id);
        // 补充默认值
        Date now = new Date();
        dto.setCreateTime(now);
        dto.setUpdateTime(now);
        dto.setStatus(1); // 初始状态：1=启用
        dto.setRevision(1);
        // 插入数据库
        boolean success = this.insert(dto);
        log.info("新增供应商结果：ID={}，名称={}，成功={}", id, saveBO.getSupplierName(), success);
        return success;
    }

    /**     * 分页查询供应商列表     */
    @Override
    public Page<SupplierInfoDTO> queryPageList(Integer pageNo, Integer pageSize, SupplierInfoBO bo) {
        int page = (pageNo == null || pageNo < 1) ? 1 : pageNo;
        int size = (pageSize == null || pageSize < 1) ? 10 : pageSize;
        Page<SupplierInfoDTO> pageObj = new Page<>(page, size);
        EntityWrapper<SupplierInfoDTO> wrapper = new EntityWrapper<>();
        wrapper.ne("status", 2); // 排除已删除

        // 关键词搜索
        if (bo != null && org.apache.commons.lang3.StringUtils.isNotBlank(bo.getKeyword())) {
            String keyword = bo.getKeyword();
            // 尝试将关键词转换为数字（匹配ID）
            try {
                Long id = Long.parseLong(keyword);
                wrapper.eq("id", id);
            } catch (NumberFormatException e) {
                // 不是数字则匹配名称模糊查询
                wrapper.like("supplier_name", keyword);
            }
        }

        // 状态和时间筛选
        if (bo != null && bo.getStatus() != null) {
            wrapper.eq("status", bo.getStatus());
        }
        if (bo != null && bo.getStartDate() != null) {
            wrapper.ge("create_time", bo.getStartDate());
        }
        if (bo != null && bo.getEndDate() != null) {
            wrapper.le("create_time", bo.getEndDate());
        }

        wrapper.orderBy("update_time", false);
        return this.selectPage(pageObj, wrapper);
    }

    /**     * 根据ID查询供应商详情     */
    @Override
    public SupplierInfoDTO selectById(Long id) {
        if (id == null || id <= 0) {
            log.warn("查询供应商详情失败：ID无效（id={}）", id);
            return null;
        }
        SupplierInfoDTO dto = this.baseMapper.selectById(id);
        log.info("查询供应商详情：ID={}，存在={}", id, dto != null);
        return dto;
    }

    /**     * 更新供应商状态（启用/禁用）     */
    @Override
    public boolean updateStatus(Long id, Integer status) {
        // 参数校验
        if (id == null || id <= 0) {
            log.warn("更新供应商状态失败：ID无效（id={}）", id);
            return false;
        }
        if (status == null || (status != 0 && status != 1)) {
            log.warn("更新供应商状态失败：状态无效（status={}，仅支持0=禁用/1=启用）", status);
            return false;
        }
        // 校验供应商是否存在且未删除
        SupplierInfoDTO existDto = this.selectById(id);
        if (existDto == null) {
            log.warn("更新供应商状态失败：ID={}的供应商不存在", id);
            return false;
        }
        if (existDto.getStatus() == 2) {
            log.warn("更新供应商状态失败：ID={}的供应商已删除，无法修改状态", id);
            return false;
        }
        if (existDto.getStatus().equals(status)) {
            log.info("更新供应商状态：ID={}，当前状态已为{}，无需重复操作", id, status);
            return true;
        }
        // 构建更新对象
        SupplierInfoDTO updateDto = new SupplierInfoDTO();
        updateDto.setId(id);
        updateDto.setStatus(status);
        updateDto.setUpdateTime(new Date());
        updateDto.setRevision(existDto.getRevision() + 1);
        // 执行更新
        boolean success = this.updateById(updateDto);
        log.info("更新供应商状态结果：ID={}，旧状态={}，新状态={}，成功={}", id, existDto.getStatus(), status, success);
        return success;
    }

    /**     * 软删除供应商     */
    @Override
    public boolean deleteById(Long id) {
        // 参数校验
        if (id == null || id <= 0) {
            log.warn("删除供应商失败：ID无效（id={}）", id);
            return false;
        }
        // 校验供应商是否存在且未删除
        SupplierInfoDTO existDto = this.selectById(id);
        if (existDto == null) {
            log.warn("删除供应商失败：ID={}的供应商不存在", id);
            return false;
        }
        if (existDto.getStatus() == 2) {
            log.info("删除供应商：ID={}的供应商已删除，无需重复操作", id);
            return true;
        }
        // 软删除
        SupplierInfoDTO deleteDto = new SupplierInfoDTO();
        deleteDto.setId(id);
        deleteDto.setStatus(2); // 软删除标记
        deleteDto.setUpdateTime(new Date());
        deleteDto.setRevision(existDto.getRevision() + 1);
        // 执行更新
        boolean success = this.updateById(deleteDto);
        log.info("软删除供应商结果：ID={}，原状态={}，成功={}", id, existDto.getStatus(), success);
        return success;
    }

    /**     * 更新供应商信息（全量更新）     */
    @Override
    public boolean update(SupplierInfoSaveBO saveBO) {
        // 参数校验
        if (saveBO == null || saveBO.getId() == null || saveBO.getId() <= 0) {
            log.warn("更新供应商信息失败：ID无效或SaveBO为空（id={}）", saveBO != null ? saveBO.getId() : null);
            return false;
        }
        // 校验供应商是否存在且未删除
        SupplierInfoDTO existDto = this.selectById(saveBO.getId());
        if (existDto == null) {
            log.warn("更新供应商信息失败：ID={}的供应商不存在", saveBO.getId());
            return false;
        }
        if (existDto.getStatus() == 2) {
            log.warn("更新供应商信息失败：ID={}的供应商已删除，无法修改", saveBO.getId());
            return false;
        }
        // 构建更新对象
        SupplierInfoDTO updateDto = new SupplierInfoDTO();
        BeanUtils.copyProperties(saveBO, updateDto);
        updateDto.setId(saveBO.getId());
        updateDto.setUpdateTime(new Date());
        updateDto.setRevision(existDto.getRevision() + 1);
        // 保留创建时间不变
        updateDto.setCreateTime(existDto.getCreateTime());
        // 执行更新
        boolean success = this.updateById(updateDto);
        log.info("更新供应商信息结果：ID={}，名称={}，成功={}", saveBO.getId(), saveBO.getSupplierName(), success);
        return success;
    }
}